In software engineering, testing is often performed to ensure software functionality. To test the software requirements, test cases, conditions, or variables are created to determine if the requirements are satisfied. Many test cases may be needed to determine if a particular requirement is fully satisfied.
A problem with this software testing is that there can be a large number of errors in an application. During testing, a fault may occur due to a programming error. However, in such cases, it may not be known which part of the code caused the error. Other times, it may be difficult to determine what portion of the test case triggered the error.
In order to identify and fix the bug, the test steps are repeated to duplicate the error. However, bugs that occur infrequently may be difficult to find in testing and it may not be possible to troubleshoot errors that cannot be reproduced. Sometimes, this can be because the size of the test can vary with the number of test steps within a test case. As such, there is no limit to the number of test steps within a particular test case. Further, in product testing, there may be more than one engineer performing the testing and this may lead to duplication of testing as each engineer can check a single code path multiple times.
The traditional way of testing is to execute test cases that are written according to a test strategy, test design specification, or the software documentation. The tester writing the test cases typically does not apply any standardized procedure while developing the test cases. There is no standard limit maintained as to how many test steps should be within a test case. Therefore, there can be any number of test steps written for a particular test case. Moreover, a tester may write test cases without knowing the complexity or paths involved in those test steps. Also, the complication or difficulty involved in organizing the test setup for executing the test steps may not be known to the tester while writing the test steps.
The greater the number of test steps within the test case, the more complex it is to execute the test steps. Overly complex test cases are more prone to error and are harder to execute. Also, the time to complete a test case increases as the number of test steps within the test case increases. This leads to test cases varying in execution time. Thus, it is difficult to estimate the execution time of the test cases. Therefore, there is a need for a way to develop test cases that are effective but not overly complicated.